// $ANTLR 3.0.1 C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g 2008-03-31 22:21:47

package edu.calvin.djs32.cs214.interpreters.frontend;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;


import org.antlr.runtime.tree.*;

@SuppressWarnings("all")
public class Hobbes2008Parser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "TUPLE", "APPLICATION", "IF", "ELSE", "THEN", "END", "NUMBER", "HEXDIGIT", "SIGN", "INTEGER", "IDENTIFIER", "WHITESPACE", "COMMENTS", "STRING", "COMMA", "LPAREN", "RPAREN"
    };
    public static final int COMMA=18;
    public static final int HEXDIGIT=11;
    public static final int END=9;
    public static final int APPLICATION=5;
    public static final int NUMBER=10;
    public static final int STRING=17;
    public static final int THEN=8;
    public static final int TUPLE=4;
    public static final int COMMENTS=16;
    public static final int WHITESPACE=15;
    public static final int INTEGER=13;
    public static final int ELSE=7;
    public static final int IF=6;
    public static final int EOF=-1;
    public static final int RPAREN=20;
    public static final int SIGN=12;
    public static final int LPAREN=19;
    public static final int IDENTIFIER=14;

        public Hobbes2008Parser(TokenStream input) {
            super(input);
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g"; }

     
      protected void mismatch(IntStream input, int ttype, BitSet follow) 
        throws RecognitionException { 
        throw new MismatchedTokenException(ttype, input); 
      } 
      public void recoverFromMismatchedSet(IntStream input, RecognitionException e, BitSet follow) 
        throws RecognitionException { 
        throw e; 
      } 


    public static class program_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start program
    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:54:1: program : expression EOF ;
    public final program_return program() throws RecognitionException {
        program_return retval = new program_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token EOF2=null;
        expression_return expression1 = null;


        Object EOF2_tree=null;

        try {
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:54:8: ( expression EOF )
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:54:10: expression EOF
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_expression_in_program106);
            expression1=expression();
            _fsp--;

            adaptor.addChild(root_0, expression1.getTree());
            EOF2=(Token)input.LT(1);
            match(input,EOF,FOLLOW_EOF_in_program108); 

            }

            retval.stop = input.LT(-1);

                retval.tree = (Object)adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
         
          catch (RecognitionException e) { 
            throw e; 
          } 
        finally {
        }
        return retval;
    }
    // $ANTLR end program

    public static class expression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start expression
    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:81:1: expression : ( INTEGER | STRING | tuple | application | ife );
    public final expression_return expression() throws RecognitionException {
        expression_return retval = new expression_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token INTEGER3=null;
        Token STRING4=null;
        tuple_return tuple5 = null;

        application_return application6 = null;

        ife_return ife7 = null;


        Object INTEGER3_tree=null;
        Object STRING4_tree=null;

        try {
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:81:12: ( INTEGER | STRING | tuple | application | ife )
            int alt1=5;
            switch ( input.LA(1) ) {
            case INTEGER:
                {
                alt1=1;
                }
                break;
            case STRING:
                {
                alt1=2;
                }
                break;
            case LPAREN:
                {
                alt1=3;
                }
                break;
            case IDENTIFIER:
                {
                alt1=4;
                }
                break;
            case IF:
                {
                alt1=5;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("81:1: expression : ( INTEGER | STRING | tuple | application | ife );", 1, 0, input);

                throw nvae;
            }

            switch (alt1) {
                case 1 :
                    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:81:20: INTEGER
                    {
                    root_0 = (Object)adaptor.nil();

                    INTEGER3=(Token)input.LT(1);
                    match(input,INTEGER,FOLLOW_INTEGER_in_expression472); 
                    INTEGER3_tree = (Object)adaptor.create(INTEGER3);
                    adaptor.addChild(root_0, INTEGER3_tree);


                    }
                    break;
                case 2 :
                    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:81:30: STRING
                    {
                    root_0 = (Object)adaptor.nil();

                    STRING4=(Token)input.LT(1);
                    match(input,STRING,FOLLOW_STRING_in_expression476); 
                    STRING4_tree = (Object)adaptor.create(STRING4);
                    adaptor.addChild(root_0, STRING4_tree);


                    }
                    break;
                case 3 :
                    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:81:39: tuple
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_tuple_in_expression480);
                    tuple5=tuple();
                    _fsp--;

                    adaptor.addChild(root_0, tuple5.getTree());

                    }
                    break;
                case 4 :
                    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:81:47: application
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_application_in_expression484);
                    application6=application();
                    _fsp--;

                    adaptor.addChild(root_0, application6.getTree());

                    }
                    break;
                case 5 :
                    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:81:61: ife
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_ife_in_expression488);
                    ife7=ife();
                    _fsp--;

                    adaptor.addChild(root_0, ife7.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

                retval.tree = (Object)adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
         
          catch (RecognitionException e) { 
            throw e; 
          } 
        finally {
        }
        return retval;
    }
    // $ANTLR end expression

    public static class application_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start application
    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:82:1: application : identifier tuple -> ^( APPLICATION identifier tuple ) ;
    public final application_return application() throws RecognitionException {
        application_return retval = new application_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        identifier_return identifier8 = null;

        tuple_return tuple9 = null;


        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        RewriteRuleSubtreeStream stream_tuple=new RewriteRuleSubtreeStream(adaptor,"rule tuple");
        try {
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:82:12: ( identifier tuple -> ^( APPLICATION identifier tuple ) )
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:82:14: identifier tuple
            {
            pushFollow(FOLLOW_identifier_in_application494);
            identifier8=identifier();
            _fsp--;

            stream_identifier.add(identifier8.getTree());
            pushFollow(FOLLOW_tuple_in_application496);
            tuple9=tuple();
            _fsp--;

            stream_tuple.add(tuple9.getTree());

            // AST REWRITE
            // elements: tuple, identifier
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 82:31: -> ^( APPLICATION identifier tuple )
            {
                // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:82:34: ^( APPLICATION identifier tuple )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(adaptor.create(APPLICATION, "APPLICATION"), root_1);

                adaptor.addChild(root_1, stream_identifier.next());
                adaptor.addChild(root_1, stream_tuple.next());

                adaptor.addChild(root_0, root_1);
                }

            }



            }

            retval.stop = input.LT(-1);

                retval.tree = (Object)adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
         
          catch (RecognitionException e) { 
            throw e; 
          } 
        finally {
        }
        return retval;
    }
    // $ANTLR end application

    public static class identifier_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start identifier
    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:83:1: identifier : IDENTIFIER ;
    public final identifier_return identifier() throws RecognitionException {
        identifier_return retval = new identifier_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token IDENTIFIER10=null;

        Object IDENTIFIER10_tree=null;

        try {
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:83:11: ( IDENTIFIER )
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:83:13: IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();

            IDENTIFIER10=(Token)input.LT(1);
            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier512); 
            IDENTIFIER10_tree = (Object)adaptor.create(IDENTIFIER10);
            adaptor.addChild(root_0, IDENTIFIER10_tree);


            }

            retval.stop = input.LT(-1);

                retval.tree = (Object)adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
         
          catch (RecognitionException e) { 
            throw e; 
          } 
        finally {
        }
        return retval;
    }
    // $ANTLR end identifier

    public static class ife_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start ife
    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:84:1: ife : IF expression THEN expression ELSE expression END -> ^( IF ( expression )* ) ;
    public final ife_return ife() throws RecognitionException {
        ife_return retval = new ife_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token IF11=null;
        Token THEN13=null;
        Token ELSE15=null;
        Token END17=null;
        expression_return expression12 = null;

        expression_return expression14 = null;

        expression_return expression16 = null;


        Object IF11_tree=null;
        Object THEN13_tree=null;
        Object ELSE15_tree=null;
        Object END17_tree=null;
        RewriteRuleTokenStream stream_THEN=new RewriteRuleTokenStream(adaptor,"token THEN");
        RewriteRuleTokenStream stream_ELSE=new RewriteRuleTokenStream(adaptor,"token ELSE");
        RewriteRuleTokenStream stream_END=new RewriteRuleTokenStream(adaptor,"token END");
        RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
        RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
        try {
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:84:5: ( IF expression THEN expression ELSE expression END -> ^( IF ( expression )* ) )
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:84:8: IF expression THEN expression ELSE expression END
            {
            IF11=(Token)input.LT(1);
            match(input,IF,FOLLOW_IF_in_ife520); 
            stream_IF.add(IF11);

            pushFollow(FOLLOW_expression_in_ife522);
            expression12=expression();
            _fsp--;

            stream_expression.add(expression12.getTree());
            THEN13=(Token)input.LT(1);
            match(input,THEN,FOLLOW_THEN_in_ife524); 
            stream_THEN.add(THEN13);

            pushFollow(FOLLOW_expression_in_ife526);
            expression14=expression();
            _fsp--;

            stream_expression.add(expression14.getTree());
            ELSE15=(Token)input.LT(1);
            match(input,ELSE,FOLLOW_ELSE_in_ife528); 
            stream_ELSE.add(ELSE15);

            pushFollow(FOLLOW_expression_in_ife530);
            expression16=expression();
            _fsp--;

            stream_expression.add(expression16.getTree());
            END17=(Token)input.LT(1);
            match(input,END,FOLLOW_END_in_ife532); 
            stream_END.add(END17);


            // AST REWRITE
            // elements: expression, IF
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 84:58: -> ^( IF ( expression )* )
            {
                // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:84:61: ^( IF ( expression )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_IF.next(), root_1);

                // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:84:66: ( expression )*
                while ( stream_expression.hasNext() ) {
                    adaptor.addChild(root_1, stream_expression.next());

                }
                stream_expression.reset();

                adaptor.addChild(root_0, root_1);
                }

            }



            }

            retval.stop = input.LT(-1);

                retval.tree = (Object)adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
         
          catch (RecognitionException e) { 
            throw e; 
          } 
        finally {
        }
        return retval;
    }
    // $ANTLR end ife

    public static class tuple_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start tuple
    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:85:1: tuple : LPAREN ( expression ( COMMA expression )* )? RPAREN -> ^( TUPLE ( expression )* ) ;
    public final tuple_return tuple() throws RecognitionException {
        tuple_return retval = new tuple_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token LPAREN18=null;
        Token COMMA20=null;
        Token RPAREN22=null;
        expression_return expression19 = null;

        expression_return expression21 = null;


        Object LPAREN18_tree=null;
        Object COMMA20_tree=null;
        Object RPAREN22_tree=null;
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
        RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
        try {
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:85:6: ( LPAREN ( expression ( COMMA expression )* )? RPAREN -> ^( TUPLE ( expression )* ) )
            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:85:8: LPAREN ( expression ( COMMA expression )* )? RPAREN
            {
            LPAREN18=(Token)input.LT(1);
            match(input,LPAREN,FOLLOW_LPAREN_in_tuple547); 
            stream_LPAREN.add(LPAREN18);

            // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:85:15: ( expression ( COMMA expression )* )?
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==IF||(LA3_0>=INTEGER && LA3_0<=IDENTIFIER)||LA3_0==STRING||LA3_0==LPAREN) ) {
                alt3=1;
            }
            switch (alt3) {
                case 1 :
                    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:85:16: expression ( COMMA expression )*
                    {
                    pushFollow(FOLLOW_expression_in_tuple550);
                    expression19=expression();
                    _fsp--;

                    stream_expression.add(expression19.getTree());
                    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:85:27: ( COMMA expression )*
                    loop2:
                    do {
                        int alt2=2;
                        int LA2_0 = input.LA(1);

                        if ( (LA2_0==COMMA) ) {
                            alt2=1;
                        }


                        switch (alt2) {
                    	case 1 :
                    	    // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:85:28: COMMA expression
                    	    {
                    	    COMMA20=(Token)input.LT(1);
                    	    match(input,COMMA,FOLLOW_COMMA_in_tuple553); 
                    	    stream_COMMA.add(COMMA20);

                    	    pushFollow(FOLLOW_expression_in_tuple555);
                    	    expression21=expression();
                    	    _fsp--;

                    	    stream_expression.add(expression21.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop2;
                        }
                    } while (true);


                    }
                    break;

            }

            RPAREN22=(Token)input.LT(1);
            match(input,RPAREN,FOLLOW_RPAREN_in_tuple561); 
            stream_RPAREN.add(RPAREN22);


            // AST REWRITE
            // elements: expression
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 85:56: -> ^( TUPLE ( expression )* )
            {
                // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:85:59: ^( TUPLE ( expression )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(adaptor.create(TUPLE, "TUPLE"), root_1);

                // C:\\Users\\Derek\\workspace\\CS-214-Interpreters\\src\\edu\\calvin\\djs32\\cs214\\interpreters\\frontend\\Hobbes2008.g:85:67: ( expression )*
                while ( stream_expression.hasNext() ) {
                    adaptor.addChild(root_1, stream_expression.next());

                }
                stream_expression.reset();

                adaptor.addChild(root_0, root_1);
                }

            }



            }

            retval.stop = input.LT(-1);

                retval.tree = (Object)adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
         
          catch (RecognitionException e) { 
            throw e; 
          } 
        finally {
        }
        return retval;
    }
    // $ANTLR end tuple


 

    public static final BitSet FOLLOW_expression_in_program106 = new BitSet(new long[]{0x0000000000000000L});
    public static final BitSet FOLLOW_EOF_in_program108 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INTEGER_in_expression472 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STRING_in_expression476 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tuple_in_expression480 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_application_in_expression484 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ife_in_expression488 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifier_in_application494 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_tuple_in_application496 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_identifier512 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_ife520 = new BitSet(new long[]{0x00000000000A6040L});
    public static final BitSet FOLLOW_expression_in_ife522 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_THEN_in_ife524 = new BitSet(new long[]{0x00000000000A6040L});
    public static final BitSet FOLLOW_expression_in_ife526 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_ELSE_in_ife528 = new BitSet(new long[]{0x00000000000A6040L});
    public static final BitSet FOLLOW_expression_in_ife530 = new BitSet(new long[]{0x0000000000000200L});
    public static final BitSet FOLLOW_END_in_ife532 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_tuple547 = new BitSet(new long[]{0x00000000001A6040L});
    public static final BitSet FOLLOW_expression_in_tuple550 = new BitSet(new long[]{0x0000000000140000L});
    public static final BitSet FOLLOW_COMMA_in_tuple553 = new BitSet(new long[]{0x00000000000A6040L});
    public static final BitSet FOLLOW_expression_in_tuple555 = new BitSet(new long[]{0x0000000000140000L});
    public static final BitSet FOLLOW_RPAREN_in_tuple561 = new BitSet(new long[]{0x0000000000000002L});

}